1. Base
1. Opérateurs et fonctions Base R
Pour quoi utiliser langage R
R est un environnement puissant et extensible. Il dispose d’un large éventail de statistiques et de capacités d’analyse et de visualisation de données
- langage basé sur la notion de vecteur, ce qui simplifie les calculs mathématiques
- Manipulation, calcul et stockage des données
- Tres puissant avec les graphiques, cartographie, analisis
- Open source avec une grande communauté
- C’est gratuit
Projets R
Le plus efficace maniere de travailler avec R est en utilisant les dossiers de projets. Ca permet:
- définit automatiquement le répertoire de travail sur le dossier racine du projet
- chemins d’accès faciles aux fichiers (chemins relatifs)
- facilitez l’organization et le partage de projets et code.
Exercise
- Ouvrez RStudio et creer un nouveau project/dossier qui s’appelle “Formation_BF”.
- Dans ce dossier creer un autre dossier qui s’appelle ‘donnees’. Ajouter les données d’evaluation HSM et du MSNA 2020 dans ce dossier.
- Dans le projet ouvrez un nouveau script R (ctrl + shift + N)
L’opérateur d’assignation
Pour conserver le résultat d’une opération, on peut le stocker dans un objet à l’aide de l’opérateur d’assignation <-. Cette “flèche” stocke ce qu’il y a à sa droite dans un objet dont le nom est indiqué à sa gauche.
x <- 8
x
## [1] 8
y <- x + 6
y
## [1] 14
capitale <- "Ouagadougou"
capitale
## [1] "Ouagadougou"
Autres opérateurs importants
operateurs mathematiques
operateurs relationnel
Exercise
- Utilisez l’opérateur d’assignation pour assigner valeurs numeriques a une variable x et une variable y.
- Essayez faire quelques testes avec les operateurs relationnel
Vecteurs
- Un vecteur est un ensemble d’éléments, tous du même type.
- Vecteurs sont les blocs de construction de langage R
- Une collection de vecteurs peut être défini avec the fonction “c”
Examples comment on peut construir un vecteur manuellement:
regions <- c("Centre", "Est" , "Nord", "Sahel")
nombres <- 1:8
regions
## [1] "Centre" "Est" "Nord" "Sahel"
On peut acceder une variable dans un vecteur avec “[ ]”:
regions[2]
## [1] "Est"
operateurs logiques
Structures de données - Data Frame
Un data frame est une liste de classe “data.frame” dont tous les éléments sont de la même longueur (ou comptent le même nombre de lignes si les éléments sont des matrices).
Il est généralement représenté sous la forme d’un tableau à deux dimensions. Chaque élément de la liste sous-jacente correspond à une colonne.
On crée un data frame avec la fonction data.frame ou, pour convertir un autre type d’objet en data frame, avec as.data.frame.
- columns: variables accédé avec le signe $ dans le format “tableau$variable”
- Aussi les variables peut etre accédé avec la notation tableau[[1]]
- rows: lignes / observations
Importer csv
- On utilise le fonction ‘read.csv’ pour importer un csv. Dans un projet R il faut que mettre le chemin relatif des données.
- Normalment les donnees se convertit en format data frame avec read.csv
- C’est advisable que les noms de colonnes sont en format ‘kobo name’ avant de importer
- Aussi, quand on importe donnee dans format csv, c’est tres important definer les veleurs NA potentielles avec l’argument “na.strings”. Ca reduit des problemes a l’avenir.
hsm_df <- read.csv("donnees/tableaux/REG1903b_3_Frontiers_HSM_Burkina_Faso_2021-03-16.csv",
na.strings = c("NA", "", "N/A", "N.A.", "NnA"),
encoding = "UTF-8")
Pour acceder las variables on utilise $ ou [[ ]]
hsm_df$ic_genre
est égal à
hsm_df[[13]]
Exercise
- Importez le tableau de données d’evaluation HSM en utilisant la fonction read.csv() et appelez-le un nom pertinant avec l’opérateur d’assignation.
- Inspectez les variables avec l’operateur $
Foncions de Base R: Inspections de données
str(): detalles compact du contenu des données
class(): le type de données de la variable.
head(): les entrées de début de la variable
tail(): les entrées du fin de la variable
dim(): dimensions des tableaux (n colonnes et n observations)
nrow(): nombre de observations des tableaux
ncol(): nombre de colonnes des tableaux
length(): retourne le nombre d’éléments dans un vecteur ou un facteur
Foncions de Base R: Convertir entre differents types de données
- as.numeric(): convertit en un format numérique
- as.character(): convertit en un format de caractère
Exercise
- Inspectez les donnees HSM avec les fonctiones au dessus.
- Utilisez le $ pour faire ces operations avec une seule variable.
Foncions de Base R: fonction ‘table’
La fonction table nous permet croisser variables facilment dans le console. C’est tres utile pour des analisis rapides et pour identifiquer valeurs NA.
table(hsm_df$ic_genre)
##
## Femme Homme
## 624 1343
Et pour comparer deux variables:
table(hsm_df$ic_genre, hsm_df$admin1)
##
## Centre-Nord Est Nord Sahel
## Femme 131 262 164 67
## Homme 414 368 284 277
On peut aussi assigner un tabl
Exercise
- Utilisez la fonction table pour comparer multi variables avec les donnees HSM.
Fonctions de Base R - statistiques descriptives
Les rubriques d’aide des diverses fonctions de R contiennent une foule d’informations ainsi que des exemples d’utilisation. Leur consultation est tout à fait essentielle. Pour consulter
min(): retourne la variable moins grand (variables de caractères aussi)
max(): retourne la variable plus grand
mean(): retourne la moyenne de une ensemble de valeurs
median(): retourne la medianne de une ensemble de valeurs
range(): vecteur contenant le minimum et le maximum d’un vecteur
quantile(): quantiles empiriques
summary(): statistiques descriptives d’un échantillon
summary(hsm_df$ic_age)
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 18.00 28.00 35.00 35.45 42.00 81.00
Exercise
- Investiger les donnees dans les manieres au dessous.
Fonctions de Base R - is.na() et !is.na() - permet identifier si une variable est NA ou non.
table(is.na(hsm_df$pdi_temps_arrivee))
##
## FALSE TRUE
## 1503 464
Exercise
- Utilisez la fonction ‘is.na()’ ensemble avec la fonction table.
Fonctions de Base R: Subset
Dans R, la commande «subset» est utilisée pour filtrer les données dans une trame de données en fonction des critères que vous avez définis.
Lorsque nous sous-ensembles de données, il est recommandé de les affecter à un nouveau objet / cadre de données afin que les données ne soient pas perdues.
La fonction de subset prend la forme suivante:
subset_df <- subset(hsm_df, criteria)
Où les critères se réfèrent à une variable numérique ou catégorique. Les critères de variables catégorielles apparaissent toujours entre guillemets.
Exemples:
Variables numériques
subset_df <- subset(hsm_df, ic_age>=30)
Variables catégorielles
subset_df <- subset(hsm_df, admin1=="Est")
Exercise
- Effectuez 3 subsets de votre hsm données, en attribuant chacun à une nouvelle trame de données.
Au moins un de ces sous-ensembles doit être d’une variable catégorielle (c’est-à-dire tous «hommes») et au moins un doit être d’une variable numérique (c’est-à-dire plus ou moins d’un nombre)
Comparison entre variables
On peut utiliser cette format en dessous de pour faire une comparaison entre deux variables, isoler une réponse d’une.
mean(hsm_df$ic_age[hsm_df$admin1 == "Est"])
## [1] 31.89841
Fonctions de Base R - recherche d’éléments
%in%
L’opérateur %in% c’est tres utile. Il teste si une valeur fait partie des elements dun vecteur. Nous permet ecrire moins code. C’est particulairment utile pour faire le recodage d’un analisis avec questions multi en kobo.
regions %in% c("Est", "Nord")
## [1] FALSE TRUE TRUE FALSE
est égal à
regions == "Est" | regions == "Nord"
## [1] FALSE TRUE TRUE FALSE
Fonctions de Base R - Autres Fonctions Utiles
- round(): arrondit un nombre décimal Par example ce code va arrondir le nombre a juste un décimal:
round(102.47333, 1)
## [1] 102.5
duplicated(): identifier les valeurs en double
unique(): extraction des éléments différents d’un vecteur
which(): positions des valeurs TRUE dans un vecteur booléen
grep
Grep nous permet chercher dans donnees particulaires pour modèles spécifiques.
Par example ici on peut chercher pour “autre” apres de un “.” dans les noms de colonnes des donnees HSM.
# numeros des colonnes
noms_autres <- grep("[.]autre", names(hsm_df))
noms_autres
[1] 84 101 123 139 153 173 194 210 227 250 282 297 354
# noms des colonnes
noms_autre <- names(hsm_df)[grep(".[.]autre", names(hsm_df))]
noms_autre
[1] “pas_nourriture_raison.autre” “strat_survie.autre”
[3] “revenu_source.autre” “activites_actuelles_non.autre”
[5] “activite_agricole_perturbe.autre” “services_sante_niger.autre”
[7] “services_sante_burkina.autre” “services_sante_mali.autre”
[9] “nutri_programme.autre” “population_inquietudes.autre”
[11] “besoin_bna.autre” “bna_pas_dispo.autre”
[13] “aap.autre”
gsub
gsub nous permet remplacer carateres facilment dans les donnees. Il utilise le syntaxe de
Pour nous permetir sorter et ordonner le tableau on peut utiliser le fonction “as.datatable” ensemble avec “formattable”.
names(data)<-gsub("\\/",".",names(data))
gsub et grep utilise les modeles qui viennent des expresiones regulaires.
Expresiones Regulaires (Regex) sommaire
Site pour tester les Regex
Fonctions Apply
La famille des fonctions apply nous permet apliquer n’importe quelle fonction a un structure de données.
apply(X, MARGIN, FUN, …)
MARGIN est une variable définissant comment la fonction est appliquée: lorsque MARGIN = 1, elle s’applique sur les lignes, alors qu’avec MARGIN = 2, cela fonctionne sur les colonnes. Notez que lorsque vous utilisez la construction MARGIN = c (1,2), elle s’applique à la fois aux lignes et aux colonnes.
FUN pourrait etre toute fonction definee.
2. dplyr
2. Manipulation des données avec dplyr
ifelse
Fonction qui reçoit comme arguments une condition et le resultat ou si c’est vrai et faux. Quand c’est utilisee pour recoder, c’est normalment avisable creer un nouvelle variable.
Quand il ya plusieurs conditions c’est avisable utiliser la fonction “case_when” de dplyr (que on va couvrir plus tard)
ifelse(condition, resultat_si_vrai, resultat_si_faux)
ifelse peut etre utilisee pour remplir une nouvelle variable cree d’une autre par example:
hsm_df$ic_agees <- ifelse(hsm_df$ic_age >= 60, "oui", "non")
On peut utiliser ifelse pour la recodage des données avec %in% aussi:
hsm_df$pdi_pourcent_recode <- ifelse(hsm_df$pdi_pourcent %in% c("Moins de la moitié",
"La moitié"),
"moitie_ou_moins",
hsm_df$pdi_pourcent)
#####Exercise
- Creez une nouvelle variable recodée dans hsm_df, en utilisant une declaration ifelse.
Packages
Maintenant on va installer le package dyplr pour utiliser ses fonctions. Les packages sont installees avec la fonction install.packages("") :
install.packages("dplyr")
Chergez le package:
library(dplyr)
dplyr et ses fonctions
dplyr est une grammaire (package) de manipulation de données, fournissant un ensemble cohérent de verbes (fonctions) qui vous aident à résoudre les défis de manipulation de données les plus courants. Il fait partie du groupe de bibliothèques Tidyverse pour R.
Fonctions cles de dplyr:
case_when
La fonction case_when c’est similaire a ifelse mais plus flexible ou c’est plus facile incorporer plusieurs conditions. Le resultat de defaut c’est definee avec TRUE:
case_when(condition1 ~ resultat1, condition2 ~ resultat2, TRUE ~ resultat de defaut)
Un example d’un recodage avec case_when:
hsm_df$nour_source_recode <- case_when(hsm_df$nourriture_source == "Achetée avec de l'argent" ~ "argent",
hsm_df$nourriture_source == "Aide humanitaire/aide alimentaire gouvernementale" ~ "aide",
hsm_df$nourriture_source == "Propre production (cultivée)" ~ "propre_prod",
TRUE ~ "autre"
)
#####Exercise
- Utilisez “case_when”" pour faire une reclassification de une colonne des données HSM
Filter
filter sélectionne des lignes d’une table selon une condition. On lui passe en paramètre un test, et seules les lignes pour lesquelles ce test renvoie TRUE (vrai) sont conservées.
on peut creer un nouveau dataframe utilisant ce filter:
hsm_df_est <- hsm_df %>%
filter(admin1 == "Est")
Select
permet de sélectionner des colonnes d’un tableau de données.
select(hsm_df, admin1, admin2)
le syntaxe colonne1:colonne2 permet de selectionner toutes les colonnes situees entre colonne1 et colonne2 incluses
select(hsm_df, admin1:group_pop)
aussi on peut utiliser fonctions pour selectionner colonnes qui respecter certaines regles colonnes qui commencent avec
select(hsm_df, starts_with("pdi_"))
# colonnes qui contiennent
select(hsm_df, contains("source"))
Rename
Une variant de select est rename. Ca permet de renommer de colonnes et memetemps passer une selection.
select(hsm_df, region = admin1)
Exercise
- Renommez une colonne avec “rename”
Arrange
arrange reordonne les lignes dun tableau selon une ou plusieurs colonnes
arrange(hsm_df, admin1)
ici premier admin1 et suivant admin2 et admin3
arrange(hsm_df, admin1, admin2, admin3)
et si on veut trier une colonne par ordre decroissant on utilise la fonction desc()
arrange(hsm_df, desc(admin1))
Mutate
- ‘mutate’ permet de creer de nouvelles colonnes dans le tableau de donnees a partir de variables existantes
- mutate est efvidemment compatible avec les fonctions de recodage (ie. case_when) par example:
# avec case_when
hsm_df <- mutate(hsm_df,
ic_h_jeune = case_when(ic_genre == "Homme" & ic_age < 30 ~ "oui",
TRUE ~ "non"))
Le Pipe
- Quand on manipule un tableau de données, il est très fréquent d’enchaîner plusieurs opérations.
- ici il faut que preserver lordre des operations dans un maniere lisible aussi.
- Pipes vienent du package “magrittr” mais sont incluees avec dplyr
une maniere de faire plusiers operations est creer un objet temporaire (ici ‘est’):
hsm_df_est <- filter(hsm_df, admin1 == 'Est')
hsm_df_est <- select(hsm_df_est, admin1:info_localite)
arrange(hsm_df_est, admin2)
la maniere mieux que on va utiliser cest l’operateur pipe %>% . On peut mettre avec le hotkey ctrl + shift + M - Ca passe le code de avant comme un argument de cette nouvelle ligne. Est tres lisable et preserver l’ordre du code.
hsm_df_est <- hsm_df %>%
filter(admin1 == 'Est') %>%
select(admin1:info_localite) %>%
arrange(admin2)
Exercise
- Utilisez pipes pour faire 3 operations sur les donnees HSM et assigner a un nouveau dataframe.
Operations groupées - aggregation
Group By
group by permet de définir des groupes de lignes à partir des valeurs d’une ou plusieurs colonnes.
hsm_df %>% group_by(admin1) %>% slice(1)
- les opérations appliquées lors du calcul des valeurs des nouvelles colonnes sont appliquées groupe de lignes par groupe de lignes.
Ensemble avec Summarize
- normalment “group by” est utilisee ensemble avec “summarize” pour creer un tableau de donnees avec seulement une ligne par groupe le na.rm indique que la calcalution va eviter les donnees NA dans la calculation
hsm_df %>%
group_by(admin1) %>%
summarise(moy_age_oic = mean(ic_age, na.rm=TRUE))
## `summarise()` ungrouping output (override with `.groups` argument)
## # A tibble: 4 x 2
## admin1 moy_age_oic
## <chr> <dbl>
## 1 Centre-Nord 36.7
## 2 Est 31.9
## 3 Nord 36.1
## 4 Sahel 39.1
Exercise
- Ulisant les donnees de HSM, creez deux nouvelles variables à la fois avec group by et summarize
Joins avec dplyr
Pour joigner deux tableaux ensemble, il y a plusieurs options. Une maniere est avec dplyr et sa suite
si la meme nom de colonne existe dans les deux cotes, le syntaxe est: inner_join(x, y, by = “nom_colonne”)
si la meme nom de colonne n’existe pas, le syntaxe est: inner_join(x, y, by = c(“nom_colonne_x” = “non_colonne_y”))
Ici on va voire les options de dplyr:
4. Géospatiale
4. R Géospatiale: sf et leaflet
R pour applications geoespaciales
“sf”
Objets sf (simple features)
sf est un package fournissant un système de classes pour les données vectorielles géographiques. Il est récemment devenu le fondement de l’analyse spatiale chez R. - sf peut représenter tous les types de géométrie vectorielle courants: points, lignes, polygones et leurs versions «multi» respectives.
st_read: chargement de données vectorielles dans R (shp, geojson, kml etc).
st_as_sf: casting comme objet sf dans R (csv, excel)
Lisez donnees avec la fonction sf, “st_read”. Comme argument, on define aussi le CRS (4326 est WGS84).
bfa_admin1 <- st_read("donnees/spatiale/bfa_admin1.geojson", crs= 4326)
bfa_admin2 <- st_read("donnees/spatiale/bfa_admin2.geojson")
Exercise
- Lisez le admin2 et aussi les chemins trunk.
Avant de faire les cartes on va creer quelques variables de couleur REACH pour faciliter la creation de les styles:
# couleurs REACH
reach_rouge <- "#EE5859"
reach_rose <- "#f5a6a7"
reach_orange <- "#F69E61"
reach_gris <- "#58585A"
reach_lt_gris <- "#D1D3D4"
reach_palette_rouge <- c('#FEF2F2','#EE5859', '#772B2C')
blanc <- "#FFFFFF"
sf plot (Base R)
Nous pouvons utiliser la fonction plot pour afficher des données spatiales avec sf:
plot(bfa_admin1)
On peut voir que le résultat ici rend un nouveau tracé pour chaque attribut. Aucun de ces autres attributs n’a de sens pour tracer de cette manière, car nous voulons simplement tracer la géométrie de la couche.
Comme dans un dataframe, nous pouvons accéder à des attributs individuels avec l’opérateur ‘$’, y compris la géométrie. Avec l’argument “col” on define la couleur. Maintenant on fait ca:
plot(bfa_admin1$geometry, col= reach_lt_gris)
Adjouter couches
Nous transmettons des options supplémentaires pour une fonction spécifique comme arguments. pour ajouter une couche à la carte: utilisez l’argument add = T. couleur (col) et largeur de ligne (lwd) sont 2 autres arguments que nous pouvons ajouter:
# ajouter le couche de chemins
bfa_chemin_trunk <- st_read("donnees/spatiale/Trunk.shp")
plot(bfa_admin1$geometry, col= reach_lt_gris)
plot(bfa_chemin_trunk$geometry, add = T, col= "brown", lwd = 0.5)
Exercise
- Faisez un plot avec 2 couches
Nous pouvons utiliser des conditions comme ifelse ou case_when pour mettre en évidence une région:
plot(bfa_admin1$geometry, col = ifelse(bfa_admin1$ADM1_FR == "Est", reach_rouge, reach_lt_gris))
Leaflet
Leaflet est la principale bibliothèque JavaScript open source pour les cartes interactives adaptées aux mobiles. A ete adaptee comme une packages R aussi.
Appelez la fonction de leaflet() et assignez-le un nom. Ajoutez un pipe (%>%) pour chaque nouvelle couche.
Les options de propriété de style sont similaires au sty+le Web et peuvent être vues en entrant? addPolygons dans la console.
L’ordre dans lequel les couches sont appelées dans la fonction est l’ordre dans lequel elles apparaissent sur la carte. Par conséquent, le calque appelé dernier apparaîtra en haut.
bfa_leaflet_map <- leaflet() %>%
addPolygons(
data = bfa_admin2, # donnees de couche admin1
color = reach_gris, # couleur des frontieres
fillColor = reach_lt_gris, # couleur de remplissage
weight = 0.3, # largeur des frontieres
opacity = 1.0, # opacite
fillOpacity = 0.8,
label = bfa_admin2$ADM2_FR,
highlightOptions = highlightOptions(fillColor="white",
color="white",
weight = 1.4,
bringToFront = F)
)
# affichez la carte
bfa_leaflet_map
nous voulons maintenant ajouter des limites et des étiquettes de region. d’abord on fait une conversion de polygon a ligne pour afficher le frontieres de region.
# autre maniere de faire des lignes admin1 c'est avec un dissolve de admin2. il viens du package rmapshaper
bfa_admin1_dissolve <- rmapshaper::ms_dissolve(bfa_admin2, field="ADM1_FR")
# convert gov boundaries to lines to display on map so they do not clash with district interactivity
bfa_admin1_lignes <- st_cast(bfa_admin1_dissolve,"MULTILINESTRING")
bfa_admin1_lignes <- st_cast(bfa_admin1_lignes,"LINESTRING")
Ces frontieres vont avoir plus largeur. Ces deux couches sont ajoutés en séquence avec le pipe (%>%):
bfa_leaflet_map <- leaflet() %>%
addPolygons(
data = bfa_admin2, # donnees de couche admin1
color = reach_gris, # couleur des frontieres
fillColor = reach_lt_gris, # couleur de remplissage
weight = 0.3, # largeur des frontieres
opacity = 1.0, # opacite
fillOpacity = 0.8,
label = bfa_admin2$ADM2_FR,
highlightOptions = highlightOptions(fillColor="white",
color="white",
weight = 1.4,
bringToFront = F)
) %>%
addPolylines(
data = bfa_admin1_lignes,
color = "black",
weight = 0.8,
opacity = 0.8)
# affichez la carte
bfa_leaflet_map
Étiquetage avec leaflet
créer des centroids de polygones pour les regions avec la fonction sf “st_centroid” afin de créer des étiquettes:
# prends le controid de couche de admin1
bfa_admin1_centroid <- st_centroid(bfa_admin1)
# vérifier que le type de géométrie est un point
st_geometry_type(bfa_admin1_centroid, by_geometry = F)
## [1] POINT
## 18 Levels: GEOMETRY POINT LINESTRING POLYGON MULTIPOINT ... TRIANGLE
Plot une nouvelle carte avec des étiquettes de région à l’aide de ‘addLabelOnlyMarkers’.
bfa_leaflet_map <- leaflet() %>%
addPolygons(
data = bfa_admin2, # donnees de couche admin1
color = reach_gris, # couleur des frontieres
fillColor = reach_lt_gris, # couleur de remplissage
weight = 0.3, # largeur des frontieres
opacity = 1.0, # opacite
fillOpacity = 0.8,
label = bfa_admin2$ADM2_FR,
highlightOptions = highlightOptions(fillColor="white",
color="white",
weight = 1.4,
bringToFront = F)
) %>%
addPolylines(
data = bfa_admin1_lignes,
color = "black",
weight = 0.8,
opacity = 0.8) %>%
addLabelOnlyMarkers(
data = bfa_admin1_centroid,
label = bfa_admin1_centroid$ADM1_FR, # c'est l'atribut utilisee pour creer des etiquetes
labelOptions = labelOptions(noHide = T,
direction = 'center',
textOnly = T))
# affichez la carte
bfa_leaflet_map
Exercise
- Avec cette carte au dessus faire une déclaration de ifelse pour souligner une region avec une autre couleur.
Donnees points avec sf
Lisez les donnees SETTLEMENTS_3F_BFA_20200505.xlsx. Pour convertir a un objet spatial on utilise la fonction sf “st_as_sf”:
bfa_villages <- readxl::read_xlsx("donnees/tableaux/SETTLEMENTS_3F_BFA_20200505.xlsx", sheet = "SETTLEMENTS_3F")
Inspectez les donnees des villages pour voire les champs des latitude et longitude.
# convert to sf object and define coordinate columns in order to plot in leaflet
bfa_villages <- bfa_villages %>%
st_as_sf(
coords = c("POINT_X", "POINT_Y"), # choose lat and long columns in table
crs = 4326)
region_a_filtrer <- "Sahel"
bfa_admin1_filtree <- bfa_admin1 %>%
filter(ADM1_FR == region_a_filtrer)
villages_filtree <- st_intersection(bfa_villages, bfa_admin1_filtree)
Ajoutez les points a la carte leaflet avec la fonction “addCircleMarkers”
bfa_leaflet_map <- leaflet() %>%
addPolygons(
data = bfa_admin2, # donnees de couche admin1
color = reach_gris, # couleur des frontieres
fillColor = reach_lt_gris, # couleur de remplissage
weight = 0.3, # largeur des frontieres
opacity = 1.0, # opacite
fillOpacity = 0.8,
label = bfa_admin2$ADM2_FR,
highlightOptions = highlightOptions(fillColor="white",
color="white",
weight = 1.4,
bringToFront = F)
) %>%
addPolylines(
data = bfa_admin1_lignes,
color = "black",
weight = 0.8,
opacity = 0.8) %>%
# ajoutez points a la carte
addCircleMarkers(
data = villages_filtree,
color = reach_orange,
fillColor = reach_orange,
radius=1,
weight=0.2,
fillOpacity = 0.8,
popup = bfa_villages$NomLocalit) %>%
addLabelOnlyMarkers(
data = bfa_admin1_centroid,
label = bfa_admin1_centroid$ADM1_FR, # c'est l'atribut utilisee pour creer des etiquetes
labelOptions = labelOptions(noHide = T,
direction = 'center',
textOnly = T))
# affichez la carte
bfa_leaflet_map
zonal statistics et cartes choropleths
Telechargez les donnees de population BF de facebook
Importez les donnees avec le package raster
pop_bfa_2018 <- raster::raster("donnees/spatiale/population_bfa_2018-10-01.tif")
Maintenant on peut calculer la population des provinces de Burkina et afficher sure une carte leaflet. Pour calculer les statistiques zonales on va utiliser le package “spatialEco”.
pop_2018 <- spatialEco::zonal.stats(bfa_admin2, pop_bfa_2018, stats = "sum")
# faire un bind pour mettre les statistiques dans les donnees admin2
bfa_admin2 <- cbind(bfa_admin2, pop_2018) %>%
dplyr::rename(pop_2018 = sum.population_bfa_2018.10.01)
Finalment on fait la carte de population et define l’etiquette comme un palette REACH.
pal_population <- colorNumeric(
palette = colorRampPalette(reach_palette_rouge)(length(bfa_admin2$pop_2018)),
domain = bfa_admin2$pop_2018, na.color = reach_lt_gris)
carte_bfa_leaflet_choropleth <- leaflet() %>%
addPolygons(
data = bfa_admin2, # donnees de couche admin1
color = reach_gris, # couleur des frontieres
fillColor = ~pal_population(pop_2018), # couleur de remplissage
weight = 0.3, # largeur des frontieres
opacity = 1.0, # opacite
fillOpacity = 0.8,
label = paste0(bfa_admin2$ADM2_FR, "- Population: ", formatC(bfa_admin2$pop_2018,format="f", big.mark=",", digits=0)),
highlightOptions = highlightOptions(fillColor = reach_gris,
color = reach_gris,
weight = 1.4,
bringToFront = F)
) %>%
addPolylines(
data = bfa_admin1_lignes,
color = "black",
weight = 0.8,
opacity = 0.8) %>%
addLabelOnlyMarkers(
data = bfa_admin1_centroid,
label = bfa_admin1_centroid$ADM1_FR, # c'est l'atribut utilisee pour creer des etiquetes
labelOptions = labelOptions(noHide = T,
direction = 'center',
textOnly = T,
style = list(
"padding" = "3px 8px",
"font-family" = "Arial",
"text-shadow" = sprintf("-1px 0 %s, 0 1px %s, 1px 0 %s, 0 -1px %s, 0 0 7px %s", blanc, blanc, blanc, blanc, blanc)
))
)%>%
# ajoutez legende gradient
leaflet::addLegend(position = "bottomright",
pal = pal_population,
values = bfa_admin2$pop_2018,
title = "Population",
bins = 5,
opacity = 1) %>%
# ajoutez echelle
addScaleBar(position = "bottomleft",
scaleBarOptions(imperial = FALSE))
# affichez la carte
carte_bfa_leaflet_choropleth
6. Analyse
Introduction
Cette formation se concentre sur la façon d’analyser les données d’enquête dans R. Elle vous apprendra étape par étape comment obtenir les moyennes et les proportions de la population à partir de vos ensembles de données quantitatives, pour les échantillons non pondérés et pondérés (regroupés / stratifiés).
Il ne s’agit pas d’une formation sur le package hypegrammaR de HQ, mais utilise plutôt les célèbres packages R survey et srvyr. srvyr est construit sur l’enquête bien documentée, mais a l’avantage supplémentaire d’utiliser une syntaxe qui peut facilement être combinée avec le paquet de travail dplyr et toutes ses fonctions. De plus, srvyr renvoie les résultats dans un format standardisé, qui peut être plus facile à utiliser qu’une enquête.
Au debut on define deux objets - les donnees comme toujours et cadre d’échantillonnage qui a seulement 2 colonnes, le nom de strata et le numero de population. Normalment le format de colonne "strata’ est comme ca - unite_de_couverture + groupe_de_population (ie. est_communaute_hote ou sanmatenga_pdi)
Au debut, on va importer les donnees nettoyees de MSNA et filtrer pour population locale cette fois:
data <- read.csv("input/donnees/bfa2002_msna_jour35_nettoyage_2020.csv", na.strings = c("NA", "", "N/A"), stringsAsFactors = F) %>%
filter(group_pop == "pop_local")
Et apres le cadre d’echantillonage (sampling frame). Mais c’est necessaire proceder un peu. On veut faire un analisis au niveau de admin1.
sampling_frame <- read.csv("input/echantillon/REACH_BFA_Pop_for_weighting_20201308.csv", na.strings = c("NA", "", "N/A"), fileEncoding="UTF-8-BOM") %>%
group_by(admin1) %>%
summarize(population = sum(Total.local)) %>%
mutate(admin1 = paste0(gsub(" |-", "_", tolower(admin1)), "_pop_local")) %>%
rename(strata = admin1)
Maintenant on va creer une variable de strata dans les donnees pour faire un join avec le sampling frame.
data$strata <- paste0(data$admin1, "_", data$group_pop)
Joigner sampling frame et donnees
data <- left_join(data, sampling_frame, by = "strata")
Analyse avec Survey
Objet svydesign
Ici on conçoit un objet “design_survey” avec la fonction “svydesign”.
L’argument id définit les ID des clusters (du plus grand au plus petit). Dans le cas de l’échantillonnage stratifié uniquement, laissez l’argument vide en spécifiant ~ 1. Définissez l’argument strata comme la colonne que vous avez spécifiée ci-dessus avec les noms de strates (précédés de ~). fpc signifie «population finie correcte» et spécifie la colonne dans laquelle vous avez vos estimations de population. À l’aide de ces estimations, l’enquête calculera des statistiques pondérées.
design_survey <- svydesign(data = data, id =~1, strata = ~strata, fpc = ~population)
Survey - Analyse sans désagrégation
Avec l’objet design maintenant on peut analyser.
Pour les variables numériques et catégorielles, vous appelez la fonction svymean (). Appelez l’indicateur que vous souhaitez analyser (précédé de ~), ainsi que l’objet de conception de l’enquête. Ajoutez na.rm = TRUE si vous souhaitez exclure toutes les valeurs vides (NA). SE c’est l’erreur standarde.
Un example avec un variable numerique:
svymean(~ic_age, design_survey, na.rm = TRUE)
## mean SE
## ic_age 42.915 0.3331
Et avec une variable catégorique:
svymean(~situation_matrimoniale, design_survey, na.rm = TRUE)
## mean SE
## situation_matrimonialecelibataire 0.018076 0.0033
## situation_matrimonialedivorce 0.005398 0.0017
## situation_matrimonialeencouple 0.067811 0.0054
## situation_matrimonialemarie_monogame 0.567142 0.0107
## situation_matrimonialemarie_polygame 0.272775 0.0090
## situation_matrimonialemarie_veuf 0.068798 0.0062
Survey - Analyse avec désagrégation
Pour analyser avec une désagrégation on appelle la fonction “svyby”. C’est comme le suivant ou on define le niveau de désagrégation avec la deuxieme argument:
svyby(~taille_abri, ~admin1, design_survey, svymean, na.rm=T)
## admin1 taille_abri se
## boucle_du_mouhoun boucle_du_mouhoun 43.58971 1.329364
## cascades cascades 38.85106 2.685893
## centre centre 49.54237 2.949482
## centre_est centre_est 51.69672 3.711088
## centre_nord centre_nord 44.02723 1.349356
## centre_ouest centre_ouest 64.78030 9.684927
## centre_sud centre_sud 40.01550 3.081962
## est est 88.40262 5.918747
## hauts_bassins hauts_bassins 40.54545 3.426680
## nord nord 59.33714 2.046345
## plateau_central plateau_central 49.01587 3.677650
## sahel sahel 178.86378 44.846138
## sud_ouest sud_ouest 36.02500 2.148416
Analyse avec srvyr
Le package ‘srvyr’ s’appuie sur survey, ajoutant la capacité d’utiliser les fonctions dyplyr. #### Objet svydesign
Avec le package srvyr on define l’objet de survey design comme ca:
design_srvyr <- data %>%
as_survey_design(ids = 1, strata = strata, fpc = population)
Valeurs numeriques - sans désagrégation
Ici on va utiliser les fonctions de dplyr ensemble avec survey_mean:
design_srvyr %>%
summarise(mean = survey_mean(ic_age, na.rm = TRUE))
## # A tibble: 1 x 2
## mean mean_se
## <dbl> <dbl>
## 1 42.9 0.333
Valeurs numeriques - avec désagrégation
Ici on va utiliser le group_by de dplyr ensemble avec survey_mean:
design_srvyr %>%
group_by(admin1) %>%
summarise(mean = survey_mean(taille_abri, na.rm = TRUE, vartype = "ci"))
## # A tibble: 13 x 4
## admin1 mean mean_low mean_upp
## <chr> <dbl> <dbl> <dbl>
## 1 boucle_du_mouhoun 43.6 41.0 46.2
## 2 cascades 38.9 33.6 44.1
## 3 centre 49.5 43.8 55.3
## 4 centre_est 51.7 44.4 59.0
## 5 centre_nord 44.0 41.4 46.7
## 6 centre_ouest 64.8 45.8 83.8
## 7 centre_sud 40.0 34.0 46.1
## 8 est 88.4 76.8 100.
## 9 hauts_bassins 40.5 33.8 47.3
## 10 nord 59.3 55.3 63.3
## 11 plateau_central 49.0 41.8 56.2
## 12 sahel 179. 90.9 267.
## 13 sud_ouest 36.0 31.8 40.2
Notez que dans la sortie des résultats, il y a maintenant 4 colonnes: 1) désagrégations, 2) moyenne, 3) borne inférieure de l’intervalle de confiance et 4) borne supérieure de l’intervalle de confiance (niveau de confiance de 0,95 par défaut).
Les intervalles de confiance (IC) peuvent être utiles pour déterminer rapidement si les différences entre les groupes sont statistiquement significatives. Si les IC ne se chevauchent pas, la différence est statistiquement significative. Si les CI se chevauchent, vous devrez peut-être exécuter un test de signification pour le savoir.
Valeurs catégorielles - sans désagrégation
Ici encore on utilise le group by:
design_srvyr %>%
group_by(genre_chef_menage) %>%
summarise(mean = survey_mean(vartype = "ci"))
## # A tibble: 3 x 4
## genre_chef_menage mean mean_low mean_upp
## <chr> <dbl> <dbl> <dbl>
## 1 femme 0.0180 0.0112 0.0249
## 2 homme 0.295 0.275 0.315
## 3 <NA> 0.687 0.667 0.708
Valeurs catégorielles - avec désagrégation
Ici encore on utilise le group by mais avec tous les variables (la variable de désagrégation primiere). On utilise filtrer
design_srvyr %>%
group_by(admin1, ic_genre) %>%
summarise(mean = survey_mean(vartype = "ci"))
## # A tibble: 26 x 5
## # Groups: admin1 [13]
## admin1 ic_genre mean mean_low mean_upp
## <chr> <chr> <dbl> <dbl> <dbl>
## 1 boucle_du_mouhoun femme 0.36 0.328 0.392
## 2 boucle_du_mouhoun homme 0.64 0.608 0.672
## 3 cascades femme 0.319 0.224 0.414
## 4 cascades homme 0.681 0.586 0.776
## 5 centre femme 0.492 0.401 0.582
## 6 centre homme 0.508 0.418 0.599
## 7 centre_est femme 0.443 0.354 0.531
## 8 centre_est homme 0.557 0.469 0.646
## 9 centre_nord femme 0.297 0.252 0.342
## 10 centre_nord homme 0.703 0.658 0.748
## # ... with 16 more rows
Adjouter un nombre
Valeurs numeriques. Adjouter un mutate avec le nom “count”:
design_srvyr %>%
group_by(admin1) %>%
summarise(mean = survey_mean(ic_age, na.rm = TRUE, vartype = "ci"),
count = unweighted(sum(!is.na(ic_age))))
## # A tibble: 13 x 5
## admin1 mean mean_low mean_upp count
## <chr> <dbl> <dbl> <dbl> <int>
## 1 boucle_du_mouhoun 41.8 40.8 42.7 875
## 2 cascades 44.9 42.0 47.9 94
## 3 centre 39.2 36.7 41.6 118
## 4 centre_est 44.0 41.2 46.7 122
## 5 centre_nord 45.0 43.5 46.4 404
## 6 centre_ouest 47.9 45.2 50.7 132
## 7 centre_sud 45.7 43.2 48.2 129
## 8 est 39.5 38.6 40.5 691
## 9 hauts_bassins 40.1 37.0 43.3 110
## 10 nord 47.3 45.9 48.6 525
## 11 plateau_central 44.9 41.9 47.9 126
## 12 sahel 43.4 42.3 44.4 632
## 13 sud_ouest 39.6 37.1 42.0 120
Et valeurs catégorielles
design_srvyr %>%
group_by(admin1, ic_genre) %>%
summarise(mean = survey_mean(vartype = "ci"),
count = unweighted(n()))
## # A tibble: 26 x 6
## # Groups: admin1 [13]
## admin1 ic_genre mean mean_low mean_upp count
## <chr> <chr> <dbl> <dbl> <dbl> <int>
## 1 boucle_du_mouhoun femme 0.36 0.328 0.392 315
## 2 boucle_du_mouhoun homme 0.64 0.608 0.672 560
## 3 cascades femme 0.319 0.224 0.414 30
## 4 cascades homme 0.681 0.586 0.776 64
## 5 centre femme 0.492 0.401 0.582 58
## 6 centre homme 0.508 0.418 0.599 60
## 7 centre_est femme 0.443 0.354 0.531 54
## 8 centre_est homme 0.557 0.469 0.646 68
## 9 centre_nord femme 0.297 0.252 0.342 120
## 10 centre_nord homme 0.703 0.658 0.748 284
## # ... with 16 more rows
Analyse avec HypegrammaR
Le package hypegrammaR a été créé par IMPACT HQ pour soutenir l’analyse quantitative en R. Il met en œuvre les directives d’analyse quantitative des données IMPACT
Il est fortement recommandé d’inclure des dossiers séparés «input» et «output» dans votre projet de HypegrammaR. Le dossier «input» contient le questionnaire, la base de sondage, les données nettoyées, le plan d’analyse. Le dossier «output» contient les résultats de l’analyse.
Installez et chargez Hypegrammar
library(devtools)
devtools::install_github("https://github.com/impact-initiatives/hypegrammaR")
library(hypegrammaR)
Chargez les fichiers
assessment_data <- load_data(file = "input/donnees/bfa2002_msna_jour35_nettoyage_2020.csv") %>%
filter(group_pop == "pop_local" | group_pop == "pdi")
sampling_frame_final <- load_samplingframe(file ="input/echantillon/sampling_frame_clean.csv")
questionnaire <- load_questionnaire(data = assessment_data,
questions = questions,
choices = choices,
choices.label.column.to.use = "label"
)
analysisplan <- load_analysisplan("input/dap/dap_msna2020.csv")
Ensuite, definez la variable de stratification entre les donnees et le cadre d’echantillonage. Parallèle q’on a fait avec le preparation en utilisant le package survey.
Apres creez la variable de strata dans les donnees.
assessment_data$strata <- paste0(assessment_data$admin1, "_", assessment_data$group_pop)
Maintenant on peut appeler le poids avec la fonction “map_to_weighting”
Ici c’est important specifier le colonne specifique pour joigner les donnes avec l’echantillon.
weights <- map_to_weighting(sampling.frame = sampling_frame_final,
data.stratum.column = "strata", # la colonne strata pour joigner cote des donnees
sampling.frame.population.column = "population", # colonne avec population dans l'echantillon
sampling.frame.stratum.column = "strata" # la colonne strata pour joigner cote d'echantillon
)
Calculs non pondérés: si votre évaluation n’est pas stratifiée / pondérée, il n’est pas nécessaire de charger une base de sondage à l’étape 2. Vous devrez également supprimer les étapes 3 et 4, et supprimer la ligne «pondération» à l’étape 5.
Lancer l’analyse
results <- from_analysisplan_map_to_output(assessment_data,
analysisplan = analysisplan,
weighting = weights,
questionnaire = questionnaire,
confidence_level = 0.9)
Exportez les résultats
map_to_master_table()
results_output <- map_to_master_table(results$results, "output/analysis_results.csv")
head(results_output)
## dependent.var independent.var independent.var.value dependent.var.value
## 1 modalite group_pop pdi direct
## 2 modalite group_pop pop_local direct
## 3 modalite group_pop pdi direct
## 4 modalite group_pop pdi telephone
## 5 modalite group_pop pop_local direct
## 6 modalite group_pop pop_local telephone
## numbers se min max repeat.var repeat.var.value
## 1 1.0000000 NA NA NA admin1 centre_est
## 2 1.0000000 NA NA NA admin1 centre_est
## 3 0.4936709 NA 0.4558498 0.5314920 admin1 sahel
## 4 0.5063291 NA 0.4685080 0.5441502 admin1 sahel
## 5 0.5696203 NA 0.5371827 0.6020578 admin1 sahel
## 6 0.4303797 NA 0.3979422 0.4628173 admin1 sahel
7. Shiny
7. Introduction a Applications Shiny
Shiny
Shiny est un package R qui facilite la création d’applications Web interactives directement avec R.
Applications Shiny contiennent un script qui s’appele app.R, dans un projet R. Dans le script de app.R il y a trois composants:
Un objet de ui (interface utilisateur) qui contrôle la disposition et l’apparence
Une fonction de server
Un appel a la fonction de shinyApp, qui crée des objets d’application Shiny à partir d’une paire défini.
Installez et chargez le package de shiny:
install.packages("shiny")
library(shiny)
Une description simplifiée du contenu d’une application Shiny:
ui <- ...
server <- ...
shinyApp(ui, server)
Maintenant on va creer un application basique. C’est le plus courant utiliser la fonction fluidPage pour creer le UI. Pour le moment on va laisser vide le server. titlePanel et sidebarLayout sont les deux éléments les plus populaires à ajouter à fluidPage. Ils créent une application Shiny de base avec une barre latérale.
# Definez UI ----
ui <- fluidPage(
titlePanel("panneau de titre"),
sidebarLayout(
sidebarPanel("panneau sidebar"),
mainPanel("panneau principal")
)
)
# Definez logique du serveur ----
server <- function(input, output) {
}
# Lancez la app
shinyApp(ui, server)
runApp("ma_app") # avec le nom de l'application
Contenu HTML
On ajoute texte de HTML comme fonctions appelé avec les memes noms des tags HTML:
# Definez UI ----
ui <- fluidPage(
titlePanel("Application Shiny"),
sidebarLayout(
sidebarPanel( img(src = "www/reach_logo.png", height = 100, width = 200),
h3("Ici le panneau sidebar. C'est gris parce qu'on a adjouté l'argument 'style = color:grey' ", style = "color:grey")),
mainPanel(
p("p() crée un paragraphe de texte."),
strong("strong() rend le texte en gras."),
em("em() crée du texte en italique."),
br(),
p("span fait la même chose que div, mais il fonctionne avec",
span("groupes de mots", style = "color:red"),
"qui apparaissent à l'intérieur d'un paragraphe.")
)
)
)
# Definez logique du serveur ----
server <- function(input, output) {
}
# Lancez la app
shinyApp(ui, server)
Resultats: 
Exercise
- creez un petite UI Shiny de la même manière que ci-dessus et peuplez les panneaux sidebar et main avec texte des plusieurs formes HTML.
Ajouter des widgets
Nous ajoutons des widgets de la même manière que nous avons ajouté d’autres types de contenu HTML, dans l’objet de UI. Chaque fonction de widget nécessite plusieurs arguments. Les deux premiers arguments de chaque widget sont:
un nom pour le widget: l’utilisateur ne verra pas ce nom, mais vous pouvez l’utiliser pour accéder à la valeur du widget. Le nom doit être une chaîne de caractères.
une étiquette: cette étiquette apparaîtra avec le widget dans votre application. Il doit s’agir d’une chaîne de caractères, mais il peut s’agir d’une chaîne vide "".
Les arguments restants varient d’un widget à l’autre, en fonction de ce dont le widget a besoin pour faire son travail. Ils incluent des éléments tels que les valeurs initiales, les plages et les incréments. Vous pouvez trouver les arguments exacts nécessaires à un widget sur la page d’aide de la fonction de widget, comme ?SelectInput.
Voici des exemples des types de widgets arrangés comme fluidRow dans un fluidPage. indique que va adapter a le largeur du navigateur. Dans chaque fluidRow on define des colonnes - le premier argument est la largeur de la colonne.
# Definez UI ----
ui <- fluidPage(
titlePanel("Application Shiny"),
fluidRow(
column(6,
sliderInput("slider1", h3("input curseur"),
min = 0, max = 100, value = 50),
sliderInput("slider2", "",
min = 0, max = 100, value = c(25, 75))
),
column(3,
h3("Case à cocher unique"),
checkboxInput("checkbox", "Choix A", value = TRUE)),
),
fluidRow(
column(6,
checkboxGroupInput("checkGroup",
h3("Case à cocher multiple"),
choices = list("choix 1" = 1,
"choix 2" = 2,
"choix 3" = 3),
selected = 1)),
column(3,
fileInput("file", h3("Télécharger un fichier"))),
),
fluidRow(
column(6,
radioButtons("radio", h3("Boutons radio"),
choices = list("Choice 1" = 1, "Choice 2" = 2,
"Choice 3" = 3),selected = 1)),
column(3,
selectInput("select", h3("menu déroulant"),
choices = list("choix 1" = 1,
"choix 2" = 2,
"choix 3" = 3),
selected = 1)),
)
)
# Definez logique du serveur ----
server <- function(input, output) {
}
# Lancez la app
shinyApp(ui, server)
Afficher les outputs réactives
Regles pour outputs réactives
- utilisez une fonction Output dans l’interface utilisateur pour placer des objets réactifs dans votre application Shiny.
- utilisez une fonction render sur le serveur pour indiquer à Shiny comment construire vos objets.
- entourer les expressions R par des accolades, {}, dans chaque fonction render.
- enregistrez vos expressions de “render” dans la liste de sortie, avec une entrée pour chaque objet réactif de votre application.
- créer de la réactivité en incluant une valeur d’entrée dans une expression de “render”.
Types des outputs:
Example de un output réactive
ui <- fluidPage(
titlePanel("Groupe de population"),
sidebarLayout(
sidebarPanel(
helpText("Create Population group data"),
selectInput("var",
label = "Choisissez un groupe de population",
choices = c("PDI",
"Communauté hôte",
"Refugie"),
selected = "Communauté hôte"),
sliderInput("range",
label = "Gamme d'intérêt:",
min = 0, max = 100, value = c(0, 100))
),
mainPanel(
textOutput("selected_var"),
textOutput("min_max")
)
)
)
server <- function(input, output) {
output$selected_var <- renderText({
paste("Vous avez sélectionné", input$var)
})
output$min_max <- renderText({
paste("Vous avez choisi une gamme allant de",
input$range[1], "à", input$range[2])
})
}
shinyApp(ui, server)
Resultats: 
library(shiny)
library(plotly)
library(dplyr)
library(ggplot2)
# global - manipulation des donnees
# lisez les donnees HSM
data <- read.csv("donnees/tableaux/REG1903b_3_Frontiers_HSM_Burkina_Faso_2021-03-16.csv",
stringsAsFactors = F,
na.strings = c("NA", "N/A",""),
encoding="UTF-8")
data$type_evaluation_cort <- case_when(data$type_evaluation == "J'évalue la localité à distance avec un informateur-clé EN PERSONNE" ~ "distance_personne",
data$type_evaluation == "J'évalue la localité à distance avec un informateur-clé PAR TÉLÉPHONE" ~ "dist_telephone",
data$type_evaluation == "Visites terrains - Je suis dans la localité évaluée avec l'informateur-clé" ~ "ic")
# objet UI
ui <- bootstrapPage(
navbarPage("Exercise navbar page",
tabPanel("tab 1 - type_enquete",
sidebarLayout(
sidebarPanel(
selectInput("region",
"selectionnez base:",
choices = sort(unique(data$base)))
),
mainPanel(
plotOutput(outputId = "graphique_stacked", height = "400px", width = "450px"),
)
)),
tabPanel("tab 2 - nourriture maintenant",
sidebarLayout(
sidebarPanel(
selectInput("region2",
"selectionnez base:",
choices = sort(unique(data$base)))
),
mainPanel(
plotOutput(outputId = "graphique_stacked2", height = "400px", width = "450px"),
)
))
)
)
# fonction de server
server <- function(input, output, session) {
output$graphique_stacked <- renderPlot({
region <- input$region
data_filtree <- data %>%
filter(base == region)
ggplot(data_filtree) +
geom_bar(aes(x = global_enum_id, fill = type_evaluation_cort))+
theme(axis.text.x = element_text(angle = 90, vjust = 0.5, hjust=1))
})
output$graphique_stacked2 <- renderPlot({
region2 <- input$region2
data_filtree2 <- data %>%
filter(base == region2)
ggplot(data_filtree2) +
geom_bar(aes(x = admin2, fill = nourriture_maintenant))+
theme(axis.text.x = element_text(angle = 90, vjust = 0.5, hjust=1))
})
}
# lancer l'application
shinyApp(ui, server)
Resultats: 
Exemples intégrés.
Le package Shiny est livré avec de nombreux exemples que nous pouvons consulter pour nous aider:
runExample("01_hello") # un histogramme
runExample("02_text") # tableaux et blocs de données
runExample("03_reactivity") # une expression réactive
runExample("04_mpg") # variables globales
runExample("05_sliders") # barres de défilement
runExample("06_tabsets") # panneaux à onglets
runExample("07_widgets") # texte d'aide et boutons d'envoi
runExample("08_html") # Application Shiny construite à partir de HTML
runExample("09_upload") # assistant de téléchargement de fichiers - upload
runExample("10_download") # assistant de téléchargement de fichiers - downlaod
runExample("11_timer") # une minuterie automatisée
#### Graphique barres empilées